home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / texsrc.arc / TEX9.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  46KB  |  1,820 lines
  1. overlay "tex9"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. maincontrol () { /* 60 21 70 71 72 73 74 10 */ r_maincontrol 
  6.   integer t ; 
  7.   quarterword l ; 
  8.   eightbits c ; 
  9.   internalfont f ; 
  10.   halfword r ; 
  11.   halfword p ; 
  12.   integer k ; 
  13.   halfword q ; 
  14.   fourquarters i ; 
  15.   fourquarters j ; 
  16.   integer s ; 
  17.   boolean ligaturepres ; 
  18.   if ( eqtb [ 4063 ] .hh .v.RH != 0 ) 
  19.   begintokenli ( eqtb [ 4063 ] .hh .v.RH , 12 ) ; 
  20.   lab60: getxtoken () ; 
  21.   lab21: if ( interrupt != 0 ) 
  22.   if ( OKtointerrup ) 
  23.   {
  24.     backinput () ; 
  25.     {
  26.       if ( interrupt != 0 ) 
  27.       pauseforinst () ; 
  28.     } 
  29.     goto lab60 ; 
  30.   } 
  31.  
  32. #ifdef DEBUG
  33.   if ( panicking ) 
  34.   checkmem ( false ) ; 
  35. #endif /* DEBUG */
  36.   if ( eqtb [ 5303 ] .cint > 0 ) 
  37.   showcurcmdch () ; 
  38.   switch ( abs ( curlist .modefield ) + curcmd ) 
  39.   {case 112 : 
  40.   case 113 : 
  41.   case 168 : 
  42.     goto lab70 ; 
  43.     break ; 
  44.   case 117 : 
  45.     {
  46.       scancharnum () ; 
  47.       curchr = curval ; 
  48.       goto lab70 ; 
  49.     } 
  50.     break ; 
  51.   case 111 : 
  52.     if ( curlist .auxfield == 1000 ) 
  53.     goto lab74 ; 
  54.     else appspace () ; 
  55.     break ; 
  56.   case 165 : 
  57.   case 265 : 
  58.     goto lab74 ; 
  59.     break ; 
  60.   case 1 : 
  61.   case 101 : 
  62.   case 201 : 
  63.   case 11 : 
  64.   case 211 : 
  65.     ; 
  66.     break ; 
  67.   case 40 : 
  68.   case 140 : 
  69.   case 240 : 
  70.     {
  71.       do { getxtoken () ; 
  72.       } while ( ! ( curcmd != 10 ) ) ; 
  73.       goto lab21 ; 
  74.     } 
  75.     break ; 
  76.   case 15 : 
  77.     if ( itsallover () ) 
  78.     return ; 
  79.     break ; 
  80.   case 23 : 
  81.   case 122 : 
  82.   case 222 : 
  83.   case 70 : 
  84.   case 170 : 
  85.   case 270 : 
  86.   case 39 : 
  87.   case 45 : 
  88.   case 49 : 
  89.   case 149 : 
  90.   case 7 : 
  91.   case 107 : 
  92.   case 207 : 
  93.     reportillega () ; 
  94.     break ; 
  95.   case 8 : 
  96.   case 108 : 
  97.   case 9 : 
  98.   case 109 : 
  99.   case 18 : 
  100.   case 118 : 
  101.   case 69 : 
  102.   case 169 : 
  103.   case 51 : 
  104.   case 151 : 
  105.   case 16 : 
  106.   case 116 : 
  107.   case 50 : 
  108.   case 150 : 
  109.   case 53 : 
  110.   case 153 : 
  111.   case 66 : 
  112.   case 166 : 
  113.   case 54 : 
  114.   case 154 : 
  115.   case 55 : 
  116.   case 155 : 
  117.   case 57 : 
  118.   case 157 : 
  119.   case 56 : 
  120.   case 156 : 
  121.   case 31 : 
  122.   case 131 : 
  123.   case 52 : 
  124.   case 152 : 
  125.   case 29 : 
  126.   case 129 : 
  127.   case 47 : 
  128.   case 147 : 
  129.   case 210 : 
  130.   case 214 : 
  131.   case 215 : 
  132.   case 228 : 
  133.   case 225 : 
  134.   case 234 : 
  135.   case 237 : 
  136.     insertdollar () ; 
  137.     break ; 
  138.   case 37 : 
  139.   case 136 : 
  140.   case 236 : 
  141.     {
  142.       {
  143.     mem [(long) curlist .tailfield ] .hh .v.RH = scanrulespec () ; 
  144.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  145.       } 
  146.       if ( abs ( curlist .modefield ) == 1 ) 
  147.       curlist .auxfield = - 65536000 ; 
  148.       else if ( abs ( curlist .modefield ) == 101 ) 
  149.       curlist .auxfield = 1000 ; 
  150.     } 
  151.     break ; 
  152.   case 28 : 
  153.   case 127 : 
  154.   case 227 : 
  155.   case 229 : 
  156.     appendglue () ; 
  157.     break ; 
  158.   case 30 : 
  159.   case 130 : 
  160.   case 230 : 
  161.   case 231 : 
  162.     appendkern () ; 
  163.     break ; 
  164.   case 2 : 
  165.   case 102 : 
  166.     newsavelevel ( 1 ) ; 
  167.     break ; 
  168.   case 62 : 
  169.   case 162 : 
  170.   case 262 : 
  171.     newsavelevel ( 14 ) ; 
  172.     break ; 
  173.   case 63 : 
  174.   case 163 : 
  175.   case 263 : 
  176.     if ( curgroup == 14 ) 
  177.     unsave () ; 
  178.     else offsave () ; 
  179.     break ; 
  180.   case 3 : 
  181.   case 103 : 
  182.   case 203 : 
  183.     handlerightb () ; 
  184.     break ; 
  185.   case 22 : 
  186.   case 123 : 
  187.   case 223 : 
  188.     {
  189.       t = curchr ; 
  190.       scandimen ( false , false , false ) ; 
  191.       if ( t == 0 ) 
  192.       savestack [ saveptr + 0 ] .cint = curval ; 
  193.       else savestack [ saveptr + 0 ] .cint = - curval ; 
  194.       scanbox () ; 
  195.     } 
  196.     break ; 
  197.   case 32 : 
  198.   case 132 : 
  199.   case 232 : 
  200.     {
  201.       savestack [ saveptr + 0 ] .cint = 1073742237 + curchr ; 
  202.       scanbox () ; 
  203.     } 
  204.     break ; 
  205.   case 21 : 
  206.   case 121 : 
  207.   case 221 : 
  208.     {
  209.       savestack [ saveptr + 0 ] .cint = 0 ; 
  210.       beginbox () ; 
  211.     } 
  212.     break ; 
  213.   case 44 : 
  214.     newgraf ( curchr > 0 ) ; 
  215.     break ; 
  216.   case 12 : 
  217.   case 13 : 
  218.   case 17 : 
  219.   case 68 : 
  220.   case 4 : 
  221.   case 24 : 
  222.   case 36 : 
  223.   case 46 : 
  224.   case 48 : 
  225.   case 27 : 
  226.   case 34 : 
  227.   case 65 : 
  228.     {
  229.       backinput () ; 
  230.       newgraf ( true ) ; 
  231.     } 
  232.     break ; 
  233.   case 144 : 
  234.   case 244 : 
  235.     indentinhmod () ; 
  236.     break ; 
  237.   case 14 : 
  238.     {
  239.       normalparagr () ; 
  240.       if ( curlist .modefield > 0 ) 
  241.       buildpage () ; 
  242.     } 
  243.     break ; 
  244.   case 114 : 
  245.     {
  246.       if ( alignstate < 0 ) 
  247.       offsave () ; 
  248.       endgraf () ; 
  249.       if ( curlist .modefield == 1 ) 
  250.       buildpage () ; 
  251.     } 
  252.     break ; 
  253.   case 115 : 
  254.   case 128 : 
  255.   case 137 : 
  256.   case 125 : 
  257.   case 133 : 
  258.     headforvmode () ; 
  259.     break ; 
  260.   case 38 : 
  261.   case 138 : 
  262.   case 238 : 
  263.   case 139 : 
  264.   case 239 : 
  265.     begininserto () ; 
  266.     break ; 
  267.   case 19 : 
  268.   case 119 : 
  269.   case 219 : 
  270.     makemark () ; 
  271.     break ; 
  272.   case 43 : 
  273.   case 143 : 
  274.   case 243 : 
  275.     appendpenalt () ; 
  276.     break ; 
  277.   case 26 : 
  278.   case 126 : 
  279.   case 226 : 
  280.     deletelast () ; 
  281.     break ; 
  282.   case 25 : 
  283.   case 124 : 
  284.   case 224 : 
  285.     unpackage () ; 
  286.     break ; 
  287.   case 145 : 
  288.     appenditalic () ; 
  289.     break ; 
  290.   case 245 : 
  291.     {
  292.       mem [(long) curlist .tailfield ] .hh .v.RH = newkern ( 0 ) ; 
  293.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  294.     } 
  295.     break ; 
  296.   case 148 : 
  297.   case 248 : 
  298.     appenddiscre () ; 
  299.     break ; 
  300.   case 146 : 
  301.     makeaccent () ; 
  302.     break ; 
  303.   case 6 : 
  304.   case 106 : 
  305.   case 206 : 
  306.   case 5 : 
  307.   case 105 : 
  308.   case 205 : 
  309.     alignerror () ; 
  310.     break ; 
  311.   case 35 : 
  312.   case 135 : 
  313.   case 235 : 
  314.     noalignerror () ; 
  315.     break ; 
  316.   case 64 : 
  317.   case 164 : 
  318.   case 264 : 
  319.     omiterror () ; 
  320.     break ; 
  321.   case 33 : 
  322.   case 134 : 
  323.     initalign () ; 
  324.     break ; 
  325.   case 233 : 
  326.     if ( privileged () ) 
  327.     initalign () ; 
  328.     break ; 
  329.   case 10 : 
  330.   case 110 : 
  331.     doendv () ; 
  332.     break ; 
  333.   case 67 : 
  334.   case 167 : 
  335.   case 267 : 
  336.     cserror () ; 
  337.     break ; 
  338.   case 104 : 
  339.     initmath () ; 
  340.     break ; 
  341.   case 249 : 
  342.     if ( privileged () ) 
  343.     starteqno () ; 
  344.     break ; 
  345.   case 202 : 
  346.     {
  347.       {
  348.     mem [(long) curlist .tailfield ] .hh .v.RH = newnoad () ; 
  349.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  350.       } 
  351.       backinput () ; 
  352.       scanmath ( curlist .tailfield + 1 ) ; 
  353.     } 
  354.     break ; 
  355.   case 212 : 
  356.   case 213 : 
  357.   case 268 : 
  358.     if ( curchr < 128 ) 
  359.     setmathchar ( eqtb [ 5139 + curchr ] .hh .v.RH ) ; 
  360.     else setmathchar ( curchr ) ; 
  361.     break ; 
  362.   case 217 : 
  363.     {
  364.       scancharnum () ; 
  365.       curchr = curval ; 
  366.       if ( curchr < 128 ) 
  367.       setmathchar ( eqtb [ 5139 + curchr ] .hh .v.RH ) ; 
  368.       else setmathchar ( curchr ) ; 
  369.     } 
  370.     break ; 
  371.   case 218 : 
  372.     {
  373.       scanfifteenb () ; 
  374.       setmathchar ( curval ) ; 
  375.     } 
  376.     break ; 
  377.   case 269 : 
  378.     setmathchar ( curchr ) ; 
  379.     break ; 
  380.   case 216 : 
  381.     {
  382.       scantwentyse () ; 
  383.       setmathchar ( curval / 4096 ) ; 
  384.     } 
  385.     break ; 
  386.   case 251 : 
  387.     {
  388.       {
  389.     mem [(long) curlist .tailfield ] .hh .v.RH = newnoad () ; 
  390.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  391.       } 
  392.       mem [(long) curlist .tailfield ] .hh.b0 = curchr ; 
  393.       scanmath ( curlist .tailfield + 1 ) ; 
  394.     } 
  395.     break ; 
  396.   case 252 : 
  397.     mathlimitswi () ; 
  398.     break ; 
  399.   case 266 : 
  400.     mathradical () ; 
  401.     break ; 
  402.   case 246 : 
  403.   case 247 : 
  404.     mathac () ; 
  405.     break ; 
  406.   case 257 : 
  407.     {
  408.       scanspec () ; 
  409.       newsavelevel ( 12 ) ; 
  410.       normalparagr () ; 
  411.       pushnest () ; 
  412.       curlist .modefield = - 1 ; 
  413.       curlist .auxfield = - 65536000 ; 
  414.       if ( eqtb [ 4062 ] .hh .v.RH != 0 ) 
  415.       begintokenli ( eqtb [ 4062 ] .hh .v.RH , 11 ) ; 
  416.     } 
  417.     break ; 
  418.   case 254 : 
  419.     {
  420.       mem [(long) curlist .tailfield ] .hh .v.RH = newstyle ( curchr ) ; 
  421.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  422.     } 
  423.     break ; 
  424.   case 256 : 
  425.     {
  426.       {
  427.     mem [(long) curlist .tailfield ] .